package com.sihai.ehr.web.action.invite;

import com.sihai.core.LimitedList;
import com.sihai.core.beans.BeanInject;
import com.sihai.ehr.model.biz.*;
import com.sihai.ehr.model.sys.InviteEnum;
import com.sihai.ehr.model.sys.InvitePageEnum;
import com.sihai.ehr.model.sys.Organization;
import com.sihai.ehr.service.*;
import com.sihai.ehr.utils.DateUtil;
import com.sihai.ehr.utils.StringUtil;
import com.sihai.ehr.web.action.EHRAction;
import com.sihai.ehr.web.pojo.EmployeeNoPojo;
import com.sihai.ehr.web.pojo.IdentityCardPojo;
import com.sihai.ehr.web.pojo.InterviewArrangePOJO;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.struts2.ServletActionContext;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
import org.eclipse.jdt.internal.core.util.HandleFactory;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import javax.servlet.http.HttpServletResponse;

/**
 * 招聘管理控制器
 * 
 * @author Henry-PC
 */
@Results({ @Result(name = "invite_list", location = "invite_main.jsp"),
		@Result(name = "interview_list", location = "interview_list.jsp"),
		@Result(name = "staff_report", location = "staff_report.jsp"),
		@Result(name = "staff_card", location = "staff_card_list.jsp"),
		@Result(name = "interview_arrtent", location = "interview_arrtent.jsp") })
public class InterviewFormAction extends EHRAction {

	Log log = LogFactory.getLog(InterviewFormAction.class);
	/**
	 * serialVersionUID
	 */
	private static final long serialVersionUID = -2942351308676108284L;

	/**********************************
	 * ---------service interface------
	 *********************************/
	/**
	 * 组织结构服务
	 */
	@BeanInject
	private OrganizationService organizationService;

	/**
	 * 职务服务
	 */
	@BeanInject
	private DutyService dutyService;

	/**
	 * 面试服务
	 */
	@BeanInject
	private InterviewService interviewService;

	/**
	 * 招聘服务
	 */
	@BeanInject
	private InviteService inviteService;

	@BeanInject
	private GradeService gradeService;

	/**********************************
	 * ---------page properties-------
	 *********************************/
	/**
	 * 组织架构Bean
	 */
	private Organization organization;
	/**
	 * 组织架构列表
	 */
	private List<Organization> organizations;

	/**
	 * 简历编号
	 */
	private Long resumeId;
	/**
	 * 页面编号
	 */
	private String p;
	/**
	 * 功能模块
	 */
	private String module;
	/**
	 * 职务ID
	 */
	private Long dutyId;
	/**
	 * 职务Bean
	 */
	private Duty duty;
	/**
	 * 职务列表
	 */
	private List<Duty> dutys;
	/**
	 * 职级ID
	 */
	private Long gradeId;

	private Long gradeLvId;

	private List<Grade> grades;

	private List<Grade> gradeLvs;

	private List<Grade> gradeRetrialLvs;

	/** 招聘安排 */
	private List<InviteArrange> inviteArranges;
	/** 面试安排对象 */
	private InterviewArrange interviewArrange;

	private LimitedList<InterviewArrangePOJO> interviewArrangePOJOs;

	private LimitedList<IdentityCardPojo> identityCardPojos;
	/**
	 * 是否发生异常
	 */
	private boolean isError = false;

	/**
	 * 移出的招聘申请ID集合
	 */
	private String ids;

	private String title;
	/**
	 * add,delete,modify
	 */
	private String operation;

	/**
	 * 面试安排结果枚举
	 */
	private String inviteviewResult;

	// ----------------员工信息资料模块-------------------
	@BeanInject
	private EmployeeService employeeService;
	private EmployeeinfoBase employeeinfoBase; // 员工基本信息
	private List<EmployeeinfoEducation> employeeinfoEducations;
	private List<EmployeeinfoTrain> employeeinfoTrains;
	private List<EmployeeinfoFamily> employeeinfoFamilies;
	private List<EmployeeWorkExperience> employeeWorkExperiences;

	// ----------------first interview and second interview------
	private Long interviewArrangeId; // 面试安排编号
	private String interviewEmployeeIds; // 面试人员编号集合

	private String signViewType; // 面试类型
	/**
	 * 初试实体
	 */
	private InterviewFirst interviewFirst;
	/**
	 * 复试实体
	 */
	private InterviewRetrial interviewRetrial;

	/**
	 * 通过列表处理页
	 * 
	 * @return
	 * @throws Exception
	 */
	@Action("/invite/invite_list")
	public String execute() throws Exception {
		try {
			// 根据传值PageNo获取页面标题及页面内容地址
			listTitle = InvitePageEnum.valueOf(p).getListTitle();
			listAction = InvitePageEnum.valueOf(p).getUrl();
			module = InvitePageEnum.valueOf(p).getBundle();
			showChildOrg = true;
			organizations = organizationService.findChildren(null, true, null,
					null);
			if (organizations != null && organizations.size() > 0) {
				if(getCurrentUserId() > 0){
	            	Long topOrgId = getCurrentUser().getWork().getOrganization().getTopOrganization().getId();
	            	Iterator<Organization> it = organizations.iterator();
	            	while(it.hasNext()){
	            		Organization o = it.next();
	            		if(o.getId() != topOrgId){
	            			it.remove();
	            		}
	            	}
	            }
				organizationId = organizations.get(0).getId();
			}
		} catch (Exception e) {
			// TODO: handle exception
		}
		return "invite_list";
	}

	/**
	 * 面试安排列表页面
	 * 
	 * @return
	 * @throws Exception
	 */
	@Action("/invite/interview_list")
	public String getInterviewList() throws Exception {

		try {
			interviewArrangePOJOs = interviewService.searchInterviewArranges(
					organizationId, dutyId, createLimit(), createSorter());
			for (Iterator iterator = interviewArrangePOJOs.iterator(); iterator
					.hasNext();) {
				InterviewArrangePOJO vPojo = (InterviewArrangePOJO) iterator
						.next();
				vPojo.setOrganization(organizationService.get(vPojo.getOrgId()));
			}
			/* 分页 */
			this.paging(interviewArrangePOJOs);
			/* 设置翻页action */
			this.setPageUrl("invite/interview_list.xhtml");
		} catch (Exception e) {
			// TODO: handle exception
		}
		return "interview_list";
	}

	/**
	 * 移动招聘安排
	 * 
	 * @return
	 * @throws Exception
	 */
	@Action(value = "/invite/interview_delete_arrange", results = { @Result(name = "success", type = "plainText") })
	public String removeInviteArrangeByIds() throws Exception {

		try {
			interviewService.removeInterviewArrange(ids);
		} catch (Exception e) {
			if (log.isErrorEnabled()) {
				log.error("【移除招聘安排申请发生异常】［错误原因：" + e.getMessage() + "］");
			}
			return ERROR;
		}
		return SUCCESS;
	}

	/**
	 * 员工报到列表页面
	 * 
	 * @return
	 * @throws Exception
	 */
	@Action("/invite/staff_report")
	public String getInterviewTOReportList() throws Exception {

		try {
			interviewArrangePOJOs = interviewService
					.searchInterviewArrangesTOReport(organizationId, dutyId,
							createLimit(), createSorter());
			for (Iterator iterator = interviewArrangePOJOs.iterator(); iterator
					.hasNext();) {
				InterviewArrangePOJO vPojo = (InterviewArrangePOJO) iterator
						.next();
				vPojo.setOrganization(organizationService.get(vPojo.getOrgId()));
			}
			/* 分页 */
			this.paging(interviewArrangePOJOs);
			/* 设置翻页action */
			this.setPageUrl("invite/staff_report.xhtml");
		} catch (Exception e) {
			// TODO: handle exception
		}
		return "staff_report";
	}

	/**
	 * 员工识别卡行为
	 * 
	 * @return
	 * @throws Exception
	 */
	@Action("/invite/staff_card")
	public String getIdentityCardList() throws Exception {
		try {
			identityCardPojos = interviewService
					.searchInterviewArrangesTOIdentityCard(organizationId,
							dutyId, createLimit(), createSorter());
			for (Iterator iterator = identityCardPojos.iterator(); iterator
					.hasNext();) {
				IdentityCardPojo vPojo = (IdentityCardPojo) iterator.next();
				vPojo.setOrganization(organizationService.get(vPojo.getOrgId()));
			}
			/* 分页 */
			this.paging(identityCardPojos);
			/* 设置翻页action */
			this.setPageUrl("invite/staff_card.xhtml");
		} catch (Exception e) {
			// TODO: handle exception
		}
		return "staff_card";
	}

	/**
	 * 添加或者修改人员面试记录
	 * 
	 * @return
	 * @throws Exception
	 */
	@Action("/invite/interview_arrtent")
	public String executeInterviewArrange() throws Exception {
		try {
			// 获取招聘安排数据集
			InviteArrange mInviteArrange = new InviteArrange();
			mInviteArrange.setCancel(false);
			inviteArranges = inviteService.searchInviteArranges(mInviteArrange,
					null, null);

			// 修改时间2012-07-22 移出招聘完成职务
			if(inviteArranges != null){
				Iterator<InviteArrange> its = inviteArranges.iterator();
				
				while(its.hasNext()){
					InviteArrange itArrange = its.next();
					if (itArrange.getCompleteNum() >= itArrange.getInviteApply().getApplyAmount()) {
						its.remove();
					}
				}
			}
		} catch (Exception e) {
			throw new RuntimeException("【加载招聘安排发生异常】【异常原因：" + e.getMessage()
					+ "】");
		}

		// 检测是否是修改申请
		if (interviewArrangeId != null && interviewArrangeId > 0) {
			title = "修改";
			try {
				interviewArrange = interviewService
						.getInterviewArrange(interviewArrangeId);
			} catch (Exception e) {
				throw new RuntimeException("【加载面试安排发生异常】【异常原因："
						+ e.getMessage() + "】");
			}
		} else {
			title = "添加";
		}
		return "interview_arrtent";
	}

	/**
	 * 提交招聘人员面试安排
	 * 
	 * {@link InviteArrange}
	 * <p>
	 * 参数值 职级编号 gradeId，面试人员集合 interviewEmployeeIds
	 * </p>
	 * 
	 * @return
	 * @throws Exception
	 */
	@Action(value = "/invite/post_interviewarrange", results = { @Result(name = "success", type = "plainText") })
	public String postInterviewArrange() throws Exception {
		// 修改处理
		if (interviewArrangeId != null && interviewArrangeId > 0) {
			interviewArrange = interviewService
					.getInterviewArrange(interviewArrangeId);
			if (interviewArrange.getGrade().getId() != gradeId) {
				Grade mGrade = gradeService.get(gradeId);
				interviewArrange.setGrade(mGrade);
				interviewArrange.setDuty(mGrade.getDuty());
				interviewArrange.setOrganization(mGrade.getDuty()
						.getOrganization());
				try {
					interviewService.saveInterviewArrange(interviewArrange);
				} catch (Exception e) {
					// e.printStackTrace();
					return ERROR;
				}
			}
		} else { // 添加处理
			try {
				Grade mGrade = gradeService.get(gradeId);
				Duty mDuty = mGrade.getDuty();
				Organization mOrganization = mDuty.getOrganization();
				if (interviewEmployeeIds != null
						&& !interviewEmployeeIds.isEmpty()) {
					for (String id : interviewEmployeeIds.split(",")) {
						InterviewArrange mInterviewArrange = new InterviewArrange();
						mInterviewArrange.setEmployeeinfoBase(employeeService
								.getEmployeeinfoBase(Long.parseLong(id)));
						mInterviewArrange.setCancel(false);
						mInterviewArrange.setDuty(mDuty);
						mInterviewArrange.setOrganization(mOrganization);
						mInterviewArrange.setGrade(mGrade);
						interviewService
								.saveInterviewArrange(mInterviewArrange);
					}
				}
			} catch (Exception e) {
				return ERROR;
			}
		}
		return SUCCESS;
	}

	/**
	 * 面试处理
	 * 
	 * @return
	 * @throws Exception
	 */
	@Action("/invite/interview_arrange")
	public String handleInterviewArrange() throws Exception {

		// e : employeeId
		if (getParameter("e") == null) {
			return ERROR;
		}
		// i : interviewarrangeid
		if (getParameter("i") == null) {
			return ERROR;
		}
		try {
			String viewType = getParameter("t") == null ? "fv" : getParameter(
					"t").toString(); // fv:初试,rv:复试
			// resumeId = Long.parseLong(getParameter("w") == null ? "-1"
			// : getParameter("w"));
			signViewType = viewType;
			interviewArrangeId = Long.parseLong(getParameter("i"));
			Long employeeId = Long.parseLong(getParameter("e"));
			employeeinfoBase = employeeService.getEmployeeinfoBase(employeeId);
			employeeinfoEducations = employeeService.getEducationList(
					employeeinfoBase, null, null);
			employeeinfoFamilies = employeeService.getEmployeeFamilyList(
					employeeinfoBase, null, null);
			employeeWorkExperiences = employeeService.getWorkExperienceList(
					employeeinfoBase, null, null);
			employeeinfoTrains = employeeService.getTrainList(employeeinfoBase,
					null, null);

			Duty vDuty = new Duty();
			vDuty.setId(dutyId);
			Grade vGrade = new Grade();
			vGrade.setDuty(vDuty);
			// 职等
			grades = gradeService.search(dutyId, "gradeName", null, null);
			// 职级
			if (grades != null && grades.size() > 0) {
				//gradeLvs = gradeService.search(vGrade, null, null);
				gradeLvs = gradeService.search(null, null, null);
				vGrade.setGradeName(grades.get(0).getGradeName());
				//gradeRetrialLvs = gradeService.search(vGrade, null, null);
				gradeRetrialLvs = gradeService.search(null, null, null);
			}

			if (interviewArrangeId > 0) {
				interviewArrange = interviewService
						.getInterviewArrange(interviewArrangeId);
				interviewFirst = interviewService
						.getInterviewFirst(interviewArrangeId);
				interviewRetrial = interviewService
						.getInterviewRetrial(interviewArrangeId);
			}
			if (interviewFirst == null) {
				interviewFirst = new InterviewFirst();
			}
			if (interviewRetrial == null) {
				interviewRetrial = new InterviewRetrial();
			}
			if(interviewFirst.getAppraiseResult() != null && 
					interviewFirst.getAppraiseResult() == InviteEnum.advice_job){
				interviewRetrial.setGradeGive(gradeService.get(interviewFirst.getGrade().getId()));
			}else{
				interviewRetrial.setGradeGive(interviewArrange.getGrade());
			}

		} catch (Exception ex) {
			ex.printStackTrace();
		}
		return "interview_arrange";
	}

	/**
	 * 提交第一次面试结果
	 * 
	 * @return
	 * @throws Exception
	 */
	@Action(value = "/invite/post_firstview", results = { @Result(name = "success", type = "plainText") })
	public String postInterviewFirst() throws Exception {

		if (interviewFirst == null) {
			if (log.isErrorEnabled()) {
				isError = true;
				return "interview_arrange";
			}
		}

		try {
			// 添加初试结果
			interviewService.saveInterviewFirst(interviewFirst, dutyId,
					organizationId);
		} catch (Exception e) {
			isError = true;
			if (log.isErrorEnabled()) {
				log.error("【添加初试记录发生异常】");
			}
			return ERROR;
		}
		return SUCCESS;
	}

	/**
	 * 提交复试结果
	 * 
	 * @return
	 * @throws Exception
	 */
	@Action(value = "/invite/post_retrialview", results = { @Result(name = "success", type = "plainText") })
	public String postInterviewRetrial() throws Exception {
		if (interviewRetrial == null) {
			if (log.isErrorEnabled()) {
				isError = true;
				return "interview_arrange";
			}
		}
		// 添加招聘申请对象
		try {
			if (getParameter("retrial_rdate") != null) {
				interviewRetrial.setRegisterDate(DateUtil
						.parseDate(getParameter("retrial_rdate")));
			}
			//@henry --->需要更新组织
			if(interviewRetrial.getGradeAdvice().getId() != null &&
					interviewRetrial.getGradeAdvice().getId() > 0){
				interviewRetrial.setGradeAdvice(gradeService.get(interviewRetrial.getGradeAdvice().getId()));
			}
			
			if(interviewRetrial.getGradeGive().getId() != null &&
					interviewRetrial.getGradeGive().getId() > 0){
				interviewRetrial.setGradeGive(gradeService.get(interviewRetrial.getGradeGive().getId()));
			}
			//@}
			interviewService.saveInterviewRetrial(interviewRetrial, dutyId,
					organizationId);
		} catch (Exception e) {
			isError = true;
			if (log.isErrorEnabled()) {
				log.error("【添加复试记录发生异常】");
			}
			return ERROR;
		}
		return SUCCESS;
	}

	/**
	 * 员工报到处理
	 * 
	 * @return
	 * @throws Exception
	 */
	@Action(value = "/invite/post_staffreport", results = { @Result(name = "success", type = "plainText") })
	public String postStaffReportState() throws Exception {
		if (interviewArrangeId == null || interviewArrangeId <= 0) {
			if (log.isErrorEnabled()) {
				isError = true;
				return ERROR;
			}
		}

		if (getParameter("checkin") == null) {
			if (log.isErrorEnabled()) {
				isError = true;
				return ERROR;
			}
		}
		InviteEnum reportStateEnum = InviteEnum
				.valueOf(getParameter("checkin"));
		InterviewArrange interviewArrange = interviewService
				.getInterviewArrange(interviewArrangeId);
		if (interviewArrange != null) {
			interviewArrange.setCheckin(reportStateEnum);
			if (reportStateEnum == InviteEnum.check_in) {
				interviewArrange.setReportTime(new Date(System
						.currentTimeMillis()));
			}
		}
		try {

			// 检测员工工号，如果是报到状态
			String employeeNo = "";
			if (reportStateEnum == InviteEnum.check_in) {
				EmployeeNoPojo workNo = employeeService
						.getEmployeeNoInfoByOrgId(interviewArrange
								.getOrganization().getId());
				if (workNo == null) {
					return ERROR;
				}
				String currEmployeeNo = employeeService.getEmployeeNo(workNo
						.getEmployeeNo());
				employeeNo = StringUtil.getNextEmployeeNo(currEmployeeNo,
						workNo);
			}

			// 添加招聘申请对象
			interviewService.saveInterviewArrange(interviewArrange);
			// 如果员工状态为已报到，修改员工状态
			if (reportStateEnum == InviteEnum.check_in) {
				// 更改人才库状态为在职员工
				EmployeeinfoBase vBase = employeeService
						.getEmployeeinfoBase(interviewArrange
								.getEmployeeinfoBase().getId());
				vBase.setState("1");
				vBase.setEntryDate(new SimpleDateFormat("yyyy-MM-dd")
						.format(new Date(System.currentTimeMillis())));
				employeeService.saveEmployeeBase(vBase);
				// 添加任职流程
				EmployeeinfoWork work = employeeService
						.getEmplyeeinfoWorkByBaseId(vBase.getId());
				if (work == null) {
					work = new EmployeeinfoWork();
					work.setBaseId(vBase);
					work.setWorkNo(employeeNo);
				}
				work.setDuty(interviewArrange.getDuty());
				work.setOrganization(interviewArrange.getOrganization());
				work.setGrade(interviewArrange.getGrade());
				work.setGradeLevel(interviewArrange.getGrade());
				work.setDismission("0");
				work.setCancel("0");
				employeeService.saveEmployeeinfoWork(work);

				// 返回任职ID
				HttpServletResponse response = ServletActionContext
						.getResponse();
				response.getWriter().write("{\"workId\":" + work.getId() + "}");
				response.getWriter().flush();
				response.getWriter().close();
			}
		} catch (Exception e) {
			isError = true;
			if (log.isErrorEnabled()) {
				log.error("【操作员工报到时发生异常】【异常原因：" + e.getMessage() + "】【发生地点:InterviewFormAction.postStaffReportState】");
			}
			e.printStackTrace();
			return ERROR;
		}
		return SUCCESS;
	}

	/**
	 * 提交识别卡信息
	 * 
	 * @return
	 * @throws Exception
	 */
	@Action(value = "/invite/post_stafficard", results = { @Result(name = "success", type = "plainText") })
	public String postStaffIdentityCardState() throws Exception {
		if (interviewArrangeId == null || interviewArrangeId <= 0) {
			if (log.isErrorEnabled()) {
				isError = true;
				return ERROR;
			}
		}
		String opType = getParameter("op");
		if (opType == null) {
			opType = "st";
		}

		// 领取状态
		if (opType.equals("st") && getParameter("rec_state") == null) {
			if (log.isErrorEnabled()) {
				isError = true;
				return ERROR;
			}
		}

		IdentificationCard identificationCard = interviewService
				.queryIdentityCardByViewArrangeId(interviewArrangeId);
		if (identificationCard == null) {
			identificationCard = new IdentificationCard();
			InterviewArrange mInterviewArrange = interviewService
					.getInterviewArrange(interviewArrangeId);
			identificationCard.setInterviewArrange(mInterviewArrange);
			if (opType.equals("st")) {
				boolean recState = getParameter("rec_state").equals("1") ? true
						: false;
				identificationCard.setReceiveState(recState);
			} else {
				identificationCard.setDentificationCardTime(new Date(System
						.currentTimeMillis()));
			}
			identificationCard.setEmployeeinfoBase(mInterviewArrange
					.getEmployeeinfoBase());
		} else {
			if (opType.equals("st")) {
				boolean recState = getParameter("rec_state").equals("1") ? true
						: false;
				identificationCard.setReceiveState(recState);
			} else {
				identificationCard.setDentificationCardTime(new Date(System
						.currentTimeMillis()));
			}
		}
		try {
			interviewService.saveIdentificationCard(identificationCard);
		} catch (Exception e) {
			if (log.isErrorEnabled()) {
				log.error("【操作识别卡记录发生异常】［异常原因：" + e.getMessage() + "］");
			}
		}
		return SUCCESS;

	}

	/**
	 * *********************************** --------------properites-------------
	 * ************************************
	 */

	public Organization getOrganization() {
		return organization;
	}

	public void setOrganization(Organization organization) {
		this.organization = organization;
	}

	public List<Organization> getOrganizations() {
		return organizations;
	}

	public void setOrganizations(List<Organization> organizations) {
		this.organizations = organizations;
	}

	public Long getResumeId() {
		return resumeId;
	}

	public void setResumeId(Long resumeId) {
		this.resumeId = resumeId;
	}

	public String getP() {
		return p;
	}

	public void setP(String p) {
		this.p = p;
	}

	public String getModule() {
		return module;
	}

	public void setModule(String module) {
		this.module = module;
	}

	public Long getDutyId() {
		return dutyId;
	}

	public void setDutyId(Long dutyId) {
		this.dutyId = dutyId;
	}

	public Duty getDuty() {
		return duty;
	}

	public void setDuty(Duty duty) {
		this.duty = duty;
	}

	public List<Duty> getDutys() {
		return dutys;
	}

	public void setDutys(List<Duty> dutys) {
		this.dutys = dutys;
	}

	public Long getGradeId() {
		return gradeId;
	}

	public void setGradeId(Long gradeId) {
		this.gradeId = gradeId;
	}

	public Long getGradeLvId() {
		return gradeLvId;
	}

	public void setGradeLvId(Long gradeLvId) {
		this.gradeLvId = gradeLvId;
	}

	public List<Grade> getGrades() {
		return grades;
	}

	public void setGrades(List<Grade> grades) {
		this.grades = grades;
	}

	public List<Grade> getGradeLvs() {
		return gradeLvs;
	}

	public void setGradeLvs(List<Grade> gradeLvs) {
		this.gradeLvs = gradeLvs;
	}

	public List<Grade> getGradeRetrialLvs() {
		return gradeRetrialLvs;
	}

	public void setGradeRetrialLvs(List<Grade> gradeRetrialLvs) {
		this.gradeRetrialLvs = gradeRetrialLvs;
	}

	public List<InviteArrange> getInviteArranges() {
		return inviteArranges;
	}

	public void setInviteArranges(List<InviteArrange> inviteArranges) {
		this.inviteArranges = inviteArranges;
	}

	public InterviewArrange getInterviewArrange() {
		return interviewArrange;
	}

	public void setInterviewArrange(InterviewArrange interviewArrange) {
		this.interviewArrange = interviewArrange;
	}

	public LimitedList<InterviewArrangePOJO> getInterviewArrangePOJOs() {
		return interviewArrangePOJOs;
	}

	public String getInterviewEmployeeIds() {
		return interviewEmployeeIds;
	}

	public void setInterviewEmployeeIds(String interviewEmployeeIds) {
		this.interviewEmployeeIds = interviewEmployeeIds;
	}

	public void setInterviewArrangePOJOs(
			LimitedList<InterviewArrangePOJO> interviewArrangePOJOs) {
		this.interviewArrangePOJOs = interviewArrangePOJOs;
	}

	public LimitedList<IdentityCardPojo> getIdentityCardPojos() {
		return identityCardPojos;
	}

	public void setIdentityCardPojos(
			LimitedList<IdentityCardPojo> identityCardPojos) {
		this.identityCardPojos = identityCardPojos;
	}

	public boolean isError() {
		return isError;
	}

	public void setError(boolean error) {
		isError = error;
	}

	public String getIds() {
		return ids;
	}

	public void setIds(String ids) {
		this.ids = ids;
	}

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public String getOperation() {
		return operation;
	}

	public void setOperation(String operation) {
		this.operation = operation;
	}

	public String getInviteviewResult() {
		return inviteviewResult;
	}

	public void setInviteviewResult(String inviteviewResult) {
		this.inviteviewResult = inviteviewResult;
	}

	public EmployeeinfoBase getEmployeeinfoBase() {
		return employeeinfoBase;
	}

	public void setEmployeeinfoBase(EmployeeinfoBase employeeinfoBase) {
		this.employeeinfoBase = employeeinfoBase;
	}

	public List<EmployeeinfoEducation> getEmployeeinfoEducations() {
		return employeeinfoEducations;
	}

	public void setEmployeeinfoEducations(
			List<EmployeeinfoEducation> employeeinfoEducations) {
		this.employeeinfoEducations = employeeinfoEducations;
	}

	public List<EmployeeinfoTrain> getEmployeeinfoTrains() {
		return employeeinfoTrains;
	}

	public void setEmployeeinfoTrains(List<EmployeeinfoTrain> employeeinfoTrains) {
		this.employeeinfoTrains = employeeinfoTrains;
	}

	public List<EmployeeinfoFamily> getEmployeeinfoFamilies() {
		return employeeinfoFamilies;
	}

	public void setEmployeeinfoFamilies(
			List<EmployeeinfoFamily> employeeinfoFamilies) {
		this.employeeinfoFamilies = employeeinfoFamilies;
	}

	public List<EmployeeWorkExperience> getEmployeeWorkExperiences() {
		return employeeWorkExperiences;
	}

	public void setEmployeeWorkExperiences(
			List<EmployeeWorkExperience> employeeWorkExperiences) {
		this.employeeWorkExperiences = employeeWorkExperiences;
	}

	public Long getInterviewArrangeId() {
		return interviewArrangeId;
	}

	public void setInterviewArrangeId(Long interviewArrangeId) {
		this.interviewArrangeId = interviewArrangeId;
	}

	public String getSignViewType() {
		return signViewType;
	}

	public void setSignViewType(String signViewType) {
		this.signViewType = signViewType;
	}

	public InterviewFirst getInterviewFirst() {
		return interviewFirst;
	}

	public void setInterviewFirst(InterviewFirst interviewFirst) {
		this.interviewFirst = interviewFirst;
	}

	public InterviewRetrial getInterviewRetrial() {
		return interviewRetrial;
	}

	public void setInterviewRetrial(InterviewRetrial interviewRetrial) {
		this.interviewRetrial = interviewRetrial;
	}
}
